import { message } from 'antd';

const agree1 = '<bpmn2:conditionExpression xsi:type="bpmn2:tFormalExpression"><![CDATA[${approvalResult == "Y"}]]></bpmn2:conditionExpression>';
const degree1 = '<bpmn2:conditionExpression xsi:type="bpmn2:tFormalExpression"><![CDATA[${approvalResult == "N"}]]></bpmn2:conditionExpression>';
const agree2 = '<bpmn2:conditionExpression xsi:type="bpmn2:tFormalExpression"><![CDATA[${passCount==nrOfInstances}]]></bpmn2:conditionExpression>';
const degree2 = '<bpmn2:conditionExpression xsi:type="bpmn2:tFormalExpression"><![CDATA[${rejectCount > 0}]]></bpmn2:conditionExpression>';

// 获取指定网关设置的通过或驳回数值
export function getSequenceFlowChild(xmlDoc, id) {
  const xNode = xmlDoc.getElementById(id);
  if (xNode && xNode.children != null && xNode.children.length > 0) {
    const item = xNode.children[0].innerHTML;
    switch (item) {
      case '${approvalResult == "Y"}':
      case '${passCount==nrOfInstances}':
      case '<![CDATA[${approvalResult == "Y"}]]>':
      case '<![CDATA[${passCount==nrOfInstances}]]>':
        return '1';
      case '${approvalResult == "N"}':
      case '${rejectCount &gt; 0}':
      case '<![CDATA[${approvalResult == "N"}]]>':
      case '<![CDATA[${rejectCount > 0}]]>':
        return '2';
      default: // 条件判断
        return '3';
    }
  } else {
    return '';
  }
}

// 设置指定网关在xml中的数据
export function setSequenceFlowChild(xmlDoc, id, value, tag, conditionExpression) {
  const xNode = xmlDoc.getElementById(id);
  if (value != '3') {
    xNode.innerHTML = tag ? (value === '1' ? agree2 : degree2) : value === '1' ? agree1 : degree1;
  } else {
    const sourceIds = { sourceId: xNode.getAttribute('sourceRef'), targetId: xNode.getAttribute('targetRef') };
    sessionStorage.setItem('sourceIds', JSON.stringify(sourceIds)); // 将目标和上一节点id 记录，保存的时候设置默认线路
    const str = `<![CDATA[\${instruction.result("\${${conditionExpression}}")==` + `'true'}]]>`;
    xNode.innerHTML = `<bpmn2:conditionExpression xsi:type="bpmn2:tFormalExpression">${str}</bpmn2:conditionExpression>`;
  }
}

// 根据节点id，获取对应节点的属性
export function getNodeAttr(xmlDoc, id, attr) {
  const xNode = xmlDoc.getElementById(id);
  return xNode ? xNode.getAttribute(attr) : null;
}

// 根据节点id，设置对应节点的属性
export function setNodeAttr(xmlDoc, id, attr, value) {
  xmlDoc.getElementById(id) && xmlDoc.getElementById(id).setAttribute(attr, value);
}

// 获取指定节点的子节点(multiinstanceloopcharacteristics节点)
export function getNodeChild(xmlDoc, id) {
  const xNode = xmlDoc.getElementById(id);
  return xNode.getElementsByTagName('bpmn2:multiInstanceLoopCharacteristics')[0];
}

// 获取当前usertask的任务类型
export function getTaskType(xmlDoc, id) {
  const assignee = getNodeAttr(xmlDoc, id, taskType[0].assignee);
  // 单人审批
  if (assignee !== null && assignee != taskType[2].assigneeValue && assignee != taskType[4].assigneeValue) {
    return taskTypeObj.single;
  }
  if (assignee !== null && assignee == taskType[2].assigneeValue) {
    const child = getNodeChild(xmlDoc, id);
    if (!!child && (child.getAttribute(taskType[2].childKey) === taskType[2].childValue || child.getAttribute(taskType[2].childKey) === null)) {
      if (child.innerHTML == '') {
        return taskTypeObj.concurrent; // 多人并发审批
      } else {
        return taskTypeObj.seize; // 多人抢占审批(多人抢占有子节点)
      }
    }
    // 多人顺序审批
    if (!!child && child.getAttribute(taskType[3].childKey) === taskType[3].childValue) {
      return taskTypeObj.order;
    }
  }
  // 流程发起人
  if (assignee !== null && assignee == taskType[4].assigneeValue) {
    return taskTypeObj.sponsor;
  }
  return undefined;
}

// 获取当前usertask的岗位
export function getStation(xmlDoc, id, type) {
  let attr;
  // eslint-disable-next-line default-case
  switch (type) {
    case taskTypeObj.seize:
      attr = getNodeChild(xmlDoc, id).getAttribute(taskType[1].stationkey);
      return attr ? attr.substring(9, attr.length - 1) : '';
    case taskTypeObj.concurrent:
    case taskTypeObj.order:
      attr = getNodeChild(xmlDoc, id).getAttribute(taskType[2].stationkey);
      return attr ? attr.substring(9, attr.length - 1) : '';
  }
}

// 删除指定节点下的multiInstanceLoopCharacteristics节点
export function delChildNode(xmlDoc, id) {
  const xNode = xmlDoc.getElementById(id);
  const childNode = xNode.getElementsByTagName('bpmn2:multiInstanceLoopCharacteristics');
  if (childNode && childNode.length > 0) {
    xNode.removeChild(childNode[0]);
  }
}

// 删除节点
export function delNode(xmlDoc, tagName) {
  const nodes = xmlDoc.getElementsByTagName(tagName);
  if (nodes && nodes.length > 0) {
    for (let i = nodes.length - 1; i >= 0; i--) {
      nodes[i].remove();
    }
  }
}

// 在指定节点下添加multiInstanceLoopCharacteristics节点
export function addChildNode(xmlDoc, id, station, isSequential, isSeize) {
  const xNode = xmlDoc.getElementById(id);
  xNode.innerHTML = '<bpmn2:multiInstanceLoopCharacteristics activiti:elementVariable="per"></bpmn2:multiInstanceLoopCharacteristics>';
  const child = xNode.getElementsByTagName('bpmn2:multiInstanceLoopCharacteristics')[0];
  child.setAttribute('isSequential', isSequential);
  child.setAttribute('activiti:collection', `\${station${station}}`);
  // 若是多人抢占模式
  if (isSeize) {
    child.innerHTML = '<completionCondition>${nrOfCompletedInstances==1 }</completionCondition>';
  }
}

// 删除指定节点的指定属性
export function delNodeAttr(xmlDoc, id, attr) {
  const xNode = xmlDoc.getElementById(id);
  xNode.removeAttribute(attr);
}

// 判断指定条件的前一个userTask节点类型
export function findUserTaskType(xmlDoc, flowId) {
  // 网关后一条线的sourceRef就是网关前一条线的targetRef
  // 网关前一条线的sourceRef就是要找的userTask节点
  const sourceRef = xmlDoc.getElementById(flowId).getAttribute('sourceRef');
  let preLines = xmlDoc.getElementsByTagName('bpmn2:sequenceFlow');
  let userTaskNode = '';
  preLines = Array.from(preLines); // forEach不能遍历HTML Collection，只能将其转换成数组
  preLines &&
    preLines.forEach((element) => {
      if (element.getAttribute('targetRef') == sourceRef) {
        userTaskNode = xmlDoc.getElementById(element.getAttribute('sourceRef'));
      }
    });
  if (userTaskNode != '') {
    // 多人抢占、多人并发、多人顺序
    if (userTaskNode.getAttribute('activiti:assignee') == '${per}') {
      const nodeChild = userTaskNode.getElementsByTagName('bpmn2:multiInstanceLoopCharacteristics');
      if (nodeChild && nodeChild.length > 0) {
        if (nodeChild[0].getAttribute('isSequential') == 'true') {
          return taskTypeObj.order; // 多人顺序审批
        } else {
          const nodeChild2 = nodeChild[0].firstChild;
          if (nodeChild2) {
            return taskTypeObj.seize; // 多人抢占
          } else {
            return taskTypeObj.concurrent; // 多人并发
          }
        }
      }
    } else if (userTaskNode.getAttribute('activiti:assignee') == '${starter}') {
      // 发起人
      return taskTypeObj.sponsor;
    } else {
      // 单人审批
      return taskTypeObj.single;
    }
  }
  return null;
}

// 设置该节点后一个网关的“出线”条件
export function setSequenceFlow(xmlDoc, nodeId, taskType) {
  // step1: 找出该节点的下一个节点是否是网关  sourceRef  targetRef  bpmn2:sequenceFlow  bpmn2:exclusiveGateway
  // step2：找出从网关出去的线
  // step3：根据节点类型，对出去的线做不同处理

  // 当前所有的线
  let afterLines = xmlDoc.getElementsByTagName('bpmn2:sequenceFlow');
  if (!afterLines) return;
  afterLines = Array.from(afterLines); // forEach不能遍历HTML Collection，只能将其转换成数组

  // 找出链接当前节点与网关之间的线
  for (let i = 0; i < afterLines.length; i++) {
    if (afterLines[i].getAttribute('sourceRef') == nodeId) {
      const gatwayId = afterLines[i].getAttribute('targetRef');

      // 根据网关ID，找到网关后的一条线
      for (let j = 0; j < afterLines.length; j++) {
        if (afterLines[j].getAttribute('sourceRef') == gatwayId) {
          const { innerHTML } = afterLines[j];
          let tag = -1;
          if (innerHTML.indexOf('${approvalResult == "Y"}') > -1 || innerHTML.indexOf('${passCount==nrOfInstances}') > -1) tag = '1';
          if (innerHTML.indexOf('${approvalResult == "N"}') > -1 || innerHTML.indexOf('${rejectCount > 0}') > 1) tag = '2';
          if (tag != -1) {
            switch (taskType) {
              case taskTypeObj.single:
              case taskTypeObj.seize:
              case taskTypeObj.sponsor:
                afterLines[j].innerHTML = tag == '1' ? agree1 : degree1;
                break;
              case taskTypeObj.concurrent:
              case taskTypeObj.order:
                afterLines[j].innerHTML = tag == '1' ? agree2 : degree2;
                break;
            }
          }
          break;
        }
      }
      break;
    }
  }
}

// 设置网关下默认 sequenceFlow
export function setDefualtFlow(xmlDoc, nodeId) {
  // 当前所有的线
  let afterLines = xmlDoc.getElementsByTagName('bpmn2:sequenceFlow');
  if (!afterLines) return;
  afterLines = Array.from(afterLines); // forEach不能遍历HTML Collection，只能将其转换成数组
  // 查询所有的网关
  let getWays = xmlDoc.getElementsByTagName('bpmn2:exclusiveGateway');
  if (!getWays) return;
  getWays = Array.from(getWays);
  const flagObj = {}; // 存放有公式的 网关
  getWays.map((item) => {
    const getWayId = item.getAttribute('id'); // 网关id
    // 找出网关出去的线
    for (let i = 0; i < afterLines.length; i++) {
      if (afterLines[i].getAttribute('sourceRef') == getWayId) {
        if (afterLines[i].innerHTML.indexOf('${instruction.result') > -1) {
          flagObj[getWayId] = true;
        }
      }
    }
  });
  getWays.map((item) => {
    const getWayId = item.getAttribute('id'); // 网关id
    // 找出网关出去的线
    for (let i = 0; i < afterLines.length; i++) {
      if (afterLines[i].getAttribute('sourceRef') == getWayId) {
        if (!afterLines[i].innerHTML && flagObj[getWayId]) {
          // 找到有公式的网关 并且拉出的线没有条件公式bpmn2:conditionExpression 的线 设为网关的默认值
          // 避免条件同意与否的网关 被设置默认flow
          // 不考虑网关出来的线既有公式又有同意驳回的情况,也不强制要求设置一条没有公式的线，
          xmlDoc.getElementById(getWayId).setAttribute('default', afterLines[i].getAttribute('id'));
        }
      }
    }
  });
}

// 获取审批类型枚举
export const taskType = [
  // 单人审批模式下，岗位不可选，仅可选择用户
  {
    value: '1',
    title: '单人审批',
    assignee: 'activiti:assignee', // 单人审批模式下，用户属性对应的key
  },
  // 多人抢占审批模式下，用户不可选，仅可选择岗位
  {
    value: '2',
    title: '多人抢占审批',
    // candidateGroups: "activiti:candidateGroups",  // 多人抢占模式下，岗位属性对应的key
    assignee: 'activiti:assignee', // 多人并发模式下，岗位属性对应的key
    assigneeValue: '${per}', // 多人并发模式下，岗位属性对应的value
    stationkey: 'activiti:collection',
    childKey: 'isSequential',
    childValue: 'false',
  },
  // 多人并发审批模式下，用户不可选，仅可选择岗位
  {
    value: '3',
    title: '多人并发审批',
    assignee: 'activiti:assignee', // 多人并发模式下，岗位属性对应的key
    assigneeValue: '${per}', // 多人并发模式下，岗位属性对应的value
    stationkey: 'activiti:collection',
    childKey: 'isSequential',
    childValue: 'false',
  },
  // 多人顺序审批模式下，用户不可选，仅可选择岗位
  {
    value: '4',
    title: '多人顺序审批',
    assignee: 'activiti:assignee', // 多人并发模式下，岗位属性对应的key
    assigneeValue: '${per}', // 多人并发模式下，岗位属性对应的value
    stationkey: 'activiti:collection',
    childKey: 'isSequential',
    childValue: 'true',
  },
  // 发起人
  {
    value: '5',
    title: '发起人',
    assignee: 'activiti:assignee', // 发起人模式下，用户属性对应的key
    assigneeValue: '${starter}', // 发起人模式下，属性对应的value
  },
];

export const taskTypeObj = {
  single: '1', // 单人审批
  seize: '2', // 多人抢占审批
  concurrent: '3', // 多人并发审批
  order: '4', // 多人顺序审批
  sponsor: '5', // 发起人
};
